home *** CD-ROM | disk | FTP | other *** search
/ Software Explosion / Software Explosion (Fore-Matt Home Computing)(1996).iso / games / workbench / yat-z / src / sound.c next >
C/C++ Source or Header  |  1992-07-05  |  13KB  |  406 lines
  1. /*
  2.    Auto: cc -ps -safnps <path><file>
  3.   */
  4. /****************************   Sound.c   *********************************
  5.  
  6.     Sound is copyright (c) 1988 by Richard Lee Stockton, 21305 60th Ave W.,
  7. Mountlake Terrace, Washington 98043, 206/776-1253(voice), but may be freely
  8. distributed as long as no profit is made from its distribution or sale
  9. without my written permission. I call this concept 'FreeWare', you can
  10. call it whatcha want.
  11.  
  12.     I also include the source code, (Manx Aztec 5.0a), in the hope that it
  13. will be of benefit to someone in the Amiga programming community. Feel free
  14. to alter it at will, (but at your own risk!). I _would_ appreciate
  15. receiving a copy of whatever it may become and it is always nice to receive
  16. credit, (perhaps just a few lines of glowing tribute.^)
  17.  
  18.                Long Live Leo and All the Little Schwabies!
  19.  
  20.                      To Manufacture with Manx 5.0a
  21.  
  22.                         cc -ps -safnps Sound.c
  23.                         ln +cdb Sound.o -lc16
  24.  
  25.  
  26. **************************************************************************/
  27.  
  28. #include <exec/memory.h>
  29. #include <workbench/startup.h>
  30. #include <workbench/workbench.h>
  31. #include <workbench/icon.h>
  32. #include <libraries/dosextens.h>
  33. #include <graphics/gfxbase.h>
  34. #include <devices/audio.h>
  35. #include <string.h>
  36. #include <functions.h>
  37.  
  38. /* Less than WorkBench 1.2 need not apply. That's nobody, right? ;-> */
  39.  
  40. #define  REVISION   33L
  41.  
  42. /* We'll need 4 buffers in CHIP memory, all else in FAST, if ya got it */
  43.  
  44. long  BUFSIZE = 1024L;
  45.  
  46. /* A pretty little HELP message showing valid variable ranges */
  47.  
  48. /* Probably more GLOBALS than are required. 'C' is funny stuff. */
  49. extern struct   GfxBase       *GfxBase=NULL;
  50.        struct   IOAudio       *sound[4]={NULL,NULL,NULL,NULL};
  51.        struct   Filehandle    *sFile=NULL;
  52.        struct   FileLock      *lock=NULL, *savelock=NULL;
  53.                 long          sactual=0L, sstart=0L, vol=64L, fade=0L,
  54.                                atol(), sps=0L, cycles=1L, startvol=64L,
  55.                                endvol=64L, fadevol=0L;
  56.                 short         k=0, stereo=0, left=1, right=1, compflag=0,
  57.                                statusline=1, direct=0;
  58.                 UBYTE         sunit[4]={12,10,5,3},
  59.                                sunitL[2]={1,8}, sunitR[2]={2,4};
  60.                 BOOL          help=FALSE;
  61.                 char          *sbuffer=NULL,
  62.                                *cbuf[4]={NULL,NULL,NULL,NULL},
  63.                                *SafeAllocMem(),
  64.                                *portname[4]={"Snd0","Snd1","Snd2","Snd3"};
  65.                 USHORT         loadSound(), soundSound();
  66.                 void           cleanup();
  67.  
  68. /*********** quit, give-up, go home, finish... Neatness counts! ******/
  69.  
  70. /* void quit(qstring)
  71. char    *qstring;
  72. {
  73.    cleanup(); 
  74. }
  75. */
  76. void cleanup()
  77. {
  78.    if(sound[0])      /* This cleans up the audio device stuff */
  79.    {
  80.       for(k=3;k>(-1);k--)
  81.       {
  82.          if((sound[k])&&(sound[k]->ioa_Request.io_Device))
  83.             AbortIO((struct IORequest *)sound[k]);
  84.       }
  85.       if(sound[0]->ioa_Request.io_Device)
  86.          CloseDevice((struct IORequest *)sound[0]);
  87.       for(k=3;k>(-1);k--)
  88.       {
  89.          if(sound[k]->ioa_Request.io_Message.mn_ReplyPort)
  90.             DeletePort(sound[k]->ioa_Request.io_Message.mn_ReplyPort);
  91.       }
  92.       for(k=3;k>(-1);k--)
  93.       {
  94.          if(sound[k]) FreeMem(sound[k],(long)sizeof(struct IOAudio));
  95.          if(cbuf[k])  FreeMem(cbuf[k],BUFSIZE);
  96.       }
  97.       sound[0]=sound[1]=sound[2]=NULL;
  98.    }
  99.  
  100.  
  101. /* Write any message to out. May be error or could be samples/second */
  102. /* You'll be sorry if you try to Write(Output()) to WorkBench!  8-)  */
  103.  
  104.  
  105. /* Clean up everything else */
  106.  
  107.    if(sFile)            Close((BPTR)sFile); 
  108.    if(sbuffer)          FreeMem(sbuffer,sactual);
  109.    if(!sound[3])        exit();
  110.    sbuffer=NULL;   
  111.    sactual=0L; sstart=0L; savelock=NULL; sps=0L; cycles=1L;
  112.    lock=0L; k=0; stereo=0; left=1; right=1; startvol=endvol=vol=64L;
  113. }
  114.  
  115. VOID
  116. cleanupsome()
  117. {
  118.    if(sbuffer)          FreeMem(sbuffer,sactual);
  119. }
  120. /*  Don't Allocate if Low Mem - by Bryce Nesbitt  */
  121. /* Aberations by RLS. 4096 should be fudge enough */
  122.  
  123. char *SafeAllocMem(size,flags)
  124. long size, flags;
  125. {
  126.    register char *p;
  127.    
  128.    if(p=(char *)AllocMem(size,flags))
  129.       if(AvailMem(MEMF_CHIP)<4096L) {FreeMem(p,size); return(NULL);}
  130.    return(p);
  131. }
  132.  
  133.  
  134. /******** Load SoundFile 'sPath' & set cycles-sps-stereo *******/
  135.  
  136. USHORT loadSound(sPa)
  137. char    *sPa;
  138. {
  139.    struct FileInfoBlock *finfo=NULL;
  140.    struct FileLock      *lock=NULL;
  141.           long          i, j;
  142.           char          string[5], sPath[80];
  143.           short         x, y, z;
  144. /* Allocate 256 bytes as work memory */
  145.    strcpy(sPath,sPa);
  146.    if(!(sbuffer=SafeAllocMem(256L,MEMF_CLEAR|MEMF_PUBLIC)))
  147.         return (20);
  148.  
  149. /* Check for and parse IFF data in first 256 bytes of file */
  150.  
  151.    if(!(sFile=(struct Filehandle *)Open(sPath,MODE_OLDFILE)))
  152.    {
  153.       FreeMem(sbuffer,256L);
  154.       sactual=256L; 
  155.       return (20);
  156.    }
  157.    Read((BPTR)sFile,sbuffer,256L);        /* load the 1st 256 bytes */
  158.    for(sstart=0L, sps=0L, i=0L; i<252L; i+=4L)
  159.    {
  160.       strncpy(string,sbuffer+i,4);   string[4]=NULL;
  161.       if(!(strcmp(string,"VHDR")))        /* get samples per second */
  162.       {
  163.          for(j=0L;j<(long)((UBYTE)sbuffer[i+20]);j++) sps+=256L;
  164.          sps += (long)((UBYTE)sbuffer[i+21L]);
  165.          if(sbuffer[i+23L]==1) compflag=1;
  166.          if(sbuffer[i+27L]!=1)
  167.             startvol=(64L*(long)(sbuffer[i+28L]*10+sbuffer[i+29L]))/100L;
  168.       }
  169.       if(!(strcmp(string,"CHAN")))            /* Channel Assignment */
  170.       {
  171.          if((sbuffer[i+7L]==6)||(sbuffer[i+11L]==6)) stereo=1;
  172.       }
  173.       if(!(strcmp(string,"BODY")))        /* get size of sound data */
  174.       {
  175.          for(j=0L;j<4L;j++)
  176.             sactual+=(((long)((UBYTE)sbuffer[i+7L-j]))<<(8L*j));
  177.          sstart = i+8L; i=252L;
  178.       }
  179.    }
  180.  
  181.  
  182.    FreeMem(sbuffer,256L); sbuffer=NULL;
  183.  
  184. /* Allocate memory for SOUND data. */
  185. /* Later we'll transfer in BUFSIZE chunks to contiguous CHIP memory. */
  186.  
  187.    if(AvailMem(MEMF_LARGEST)<(sactual+16384L)) direct=1;
  188.    if(direct) return(0);
  189.    if(!(sbuffer=SafeAllocMem(sactual,MEMF_CLEAR|MEMF_PUBLIC)))
  190.         return (20);
  191.  
  192. /* Load the data into sbuffer */
  193.  
  194.    Seek((BPTR)sFile,sstart,OFFSET_BEGINNING);
  195.    if((Read((BPTR)sFile,sbuffer,sactual)) == -1L) 
  196.      return (20);
  197.    Close((BPTR)sFile);  sFile=NULL;
  198.    return (0);
  199.  
  200. }
  201.  
  202.  
  203. /*****************  make a noise ******************/
  204.  
  205. USHORT soundSound()
  206. {
  207.     ULONG   class;
  208.     LONG    h, i, j, dactual, dlength, remaining;
  209.     USHORT  code, count;
  210.     short   z;
  211.  
  212. /* Make sure we have valid values before 'sounding' */
  213.  
  214.     if(left==right) left=right=1;
  215.     if((sps<56L)||(sps>65534L)) sps=10000L;
  216.     if((startvol<1L)||(startvol>64L)) startvol=64L;
  217.     vol=startvol;
  218.     if((endvol<1L)||(endvol>64L)) endvol=64L;
  219.     if(direct)
  220.     {
  221.        BUFSIZE=AvailMem(MEMF_CHIP|MEMF_LARGEST)/6L;
  222.        if(BUFSIZE>64000L) BUFSIZE=64000L;
  223.        BUFSIZE-=(BUFSIZE%8L);
  224.     }
  225.  
  226.     cycles = 1;
  227. /* Put up a 'status' window on the top line. */
  228.  
  229. /* Allocate sound data buffers from CHIP memory. Ports and */
  230. /* Audio Request Structures do NOT require CHIP memory */
  231.  
  232.    for(k=0;k<4;k++)
  233.    {
  234.      if(!(cbuf[k]=SafeAllocMem(BUFSIZE,
  235.            MEMF_CHIP|MEMF_CLEAR|MEMF_PUBLIC))) 
  236.            return (20);
  237.      if(!(sound[k]=(struct IOAudio *)SafeAllocMem((long)sizeof(struct IOAudio),
  238.                      MEMF_CLEAR|MEMF_PUBLIC))) 
  239.                      return (20);
  240.      if(!(sound[k]->ioa_Request.io_Message.mn_ReplyPort =
  241.                   CreatePort(portname[k],0L))) 
  242.                      return (20);
  243.    }
  244.  
  245. /* Open Audio using the first IOAudio as the 'initializer' request */
  246.  
  247.    sound[0]->ioa_Request.io_Message.mn_Node.ln_Pri = 114;
  248.    if(!right) sound[0]->ioa_Data   = &sunitL[0];
  249.    else if(!left) sound[0]->ioa_Data   = &sunitR[0];
  250.    else sound[0]->ioa_Data   = &sunit[0];
  251.    sound[0]->ioa_Length = 4L;
  252.    if((OpenDevice(AUDIONAME,0L,(struct IORequest *)sound[0],0L))!=NULL)
  253.    {
  254.       sound[0]->ioa_Request.io_Device=NULL;  /* don't AbortIO if no open */
  255.       return (20);
  256.    }
  257.  
  258. /* Set all IOAudios. */
  259.  
  260.    for(k=0;k<4;k++)
  261.    {
  262.       sound[k]->ioa_Request.io_Message.mn_Node.ln_Pri = 114;
  263.       sound[k]->ioa_Request.io_Command = CMD_WRITE;
  264.       sound[k]->ioa_Request.io_Flags   = ADIOF_PERVOL;
  265.  
  266. /* Note copies of Device & AllocKey from initializer. */
  267.  
  268.       sound[k]->ioa_Request.io_Device  = sound[0]->ioa_Request.io_Device;
  269.       sound[k]->ioa_AllocKey  = sound[0]->ioa_AllocKey;
  270.  
  271. /* Each IOAudio has its own CHIP buffer, Port, and Unit (left/right) */
  272.  
  273.       sound[k]->ioa_Data   = (UBYTE *)cbuf[k];
  274.  
  275. /* 3579547 divided by 55 = 65083, nearly the maximum Period (65535)  */
  276. /* changing this 'magic' number is all we need to make it 'European' */
  277.  
  278.       if(GfxBase->DisplayFlags&PAL) sound[k]->ioa_Period=3546895L/sps;
  279.                                else sound[k]->ioa_Period=3579547L/sps;
  280.  
  281. /* allow for volume setting. gives us effect possibilities in a script */
  282.  
  283.       sound[k]->ioa_Volume = startvol;
  284.  
  285. /* One time through this BUFSIZE (or smaller) part of the whole */
  286.  
  287.       sound[k]->ioa_Cycles = 1L;
  288.    }
  289.  
  290. /* The compiler wants 'Unit' to be a structure, we just want to mask */
  291. /* into the allocated left/right channels. left=1 or 8, right=2 or 4 */
  292. /*        ...zap! You're a Unit structure! Feel any different?       */
  293.  
  294.    for(k=2;k>(-1);k-=2)
  295.    {
  296.       if(right) sound[k+1]->ioa_Request.io_Unit = (struct Unit *)
  297.                       ((ULONG)(sound[0]->ioa_Request.io_Unit)&6L);
  298.       if(left)    sound[k]->ioa_Request.io_Unit  = (struct Unit *)
  299.                       ((ULONG)(sound[0]->ioa_Request.io_Unit)&9L);
  300.    }
  301.  
  302. /* If in STEREO, split file. If in MONO, 'b' buffers use 'a' data */
  303.  
  304.    if(stereo) remaining=(sactual/2L)-(sactual&1L);
  305.    else
  306.    {
  307.       remaining=sactual;
  308.       sound[1]->ioa_Data   = (UBYTE *)cbuf[0];
  309.       sound[3]->ioa_Data   = (UBYTE *)cbuf[2];
  310.    }
  311.  
  312. /* dactual is the length of one channel's complete data */
  313.  
  314.    dactual=remaining;     k=count=0;
  315.  
  316. /* if DIRECT_FROM_DISK, start at the beginning of the sample */
  317.  
  318.  
  319. /* we be doing loops here */
  320.  
  321.    do
  322.    {
  323.  
  324. /* be CERTAIN ioa_Length is an even number & set datalength */
  325.  
  326.       if(remaining>BUFSIZE) dlength=BUFSIZE;
  327.       else {dlength=remaining; dlength-=(dlength&1L);}
  328.  
  329. /* Move the data into the proper CHIP buffer of BUFSIZE */
  330.  
  331.     movmem(sbuffer+(dactual-remaining),cbuf[k],(int)dlength);
  332.  
  333. /* Don't load or use the right CHIP buffers if MONO. Saves time. */
  334.  
  335.       if(stereo)
  336.          movmem(sbuffer+(sactual-remaining),cbuf[k+1],(int)dlength);
  337.  
  338. /* Data has been moved, so adjust 'remaining' */
  339.  
  340.       remaining-=dlength;
  341.  
  342. /* Left and Right Lengths are the same, no matter what! */
  343.  
  344.       sound[k]->ioa_Length = sound[k+1]->ioa_Length = dlength;
  345.  
  346. /* Start one set of Left/Right Channels. */
  347.  
  348.       if(left)  BeginIO((struct IORequest *)sound[k]);
  349.       if(right) BeginIO((struct IORequest *)sound[k+1]);
  350.  
  351.  
  352. /* Is this the last time AND the last cycle? If yes & no, reset. */
  353.  
  354.       if(remaining<2L)
  355.       {
  356.          cycles--;
  357.          if(cycles!=0L)
  358.          {
  359.             if(direct) Seek((BPTR)sFile,sstart,OFFSET_BEGINNING);
  360.             remaining=dactual; dlength=BUFSIZE;
  361.             if(fadevol!=0L)
  362.             {
  363.                vol=vol+fadevol;
  364.             }
  365.          }
  366.       }
  367.       if(vol>64L) vol=64L;  if(vol<1L) vol=1L;
  368.       for(i=0L;(i<4L)&&(vol>=0L);i++) sound[i]->ioa_Volume = vol;
  369.  
  370. /* Is this the last time, or what? */
  371.  
  372.       if(remaining<2L)
  373.          WaitIO((struct IORequest *)sound[k+right]); /* wait for LAST request */
  374.       else
  375.       {
  376.          if(k) k=0; else k=2;    /* switch buffers & wait for PREVIOUS */
  377.          if(count++) WaitIO((struct IORequest *)sound[k+right]);
  378.       }
  379.  
  380. /* Keep going until we run out of data */
  381.  
  382.    }   while(remaining>1L); 
  383.       for(k=3;k>(-1);k--)
  384.       {
  385.          if((sound[k])&&(sound[k]->ioa_Request.io_Device))
  386.             AbortIO((struct IORequest *)sound[k]);
  387.       }
  388.       if(sound[0]->ioa_Request.io_Device)
  389.          CloseDevice((struct IORequest *)sound[0]);
  390.       for(k=3;k>(-1);k--)
  391.       {
  392.          if(sound[k]->ioa_Request.io_Message.mn_ReplyPort)
  393.             DeletePort(sound[k]->ioa_Request.io_Message.mn_ReplyPort);
  394.       }
  395.       for(k=3;k>(-1);k--)
  396.       {
  397.          if(sound[k]) FreeMem(sound[k],(long)sizeof(struct IOAudio));
  398.          if(cbuf[k])  FreeMem(cbuf[k],BUFSIZE);
  399.       }
  400.       sound[0]=sound[1]=sound[2]=NULL;
  401.       return (0);
  402. }
  403.  
  404.  
  405. /************************** end of Sound.c ******************************/
  406.